.TITLE EDIT

;DEFINED GLOBALS

.GLOBL EDIT,DEFPRO,SWITCH,DELETE,INSERT,SKIP,LAST,TERMIN,PRINT

;REQUIRED GLOBALS

.GLOBL TYPSTR,TYPERR,LINOUT,INSTR,PRTINT,GETINT,OUTBUF,INBUF
.GLOBL GETBLK,RELBLK,PUSARG,PACNME,PSTEP,EDSNUM,EDPROG,FUNTAB
.GLOBL MOTION,FSTSTP,EDITIN,TYPBIT,FUNPTR,FUNARG
.GLOBL NUMARG,STRING,NOPROG,EMTYPE


;REGISTER DEFINITIONS

R0	=%0
R1	=%1
R2	=%2
R3	=%3
R4	=%4
SG	=%5
SP	=%6
PC	=%7

;POINTERS TO VARIABLES KEEP ON THE STACK

PPTR	=4 	;PTR TO CURRENT PROGRAM SYMBOL BLOCK
SNUM	=2 	;CURRENT STEP NUMBER
OPTR	=0	;PTR TO PREVIOUS STEP BLOCK

PPTR2	=26	;POINTERS USED BY EDIT FUNCTIONS
SNUM2	=24
OPTR2	=22
;"EDIT"   - COMMAND INSTRUCTION
 
;THIS COMMAND IS USED FOR MODIFYING EXISTING MOTION INSTRUCTION
;STEPS.  THE REQUIRED ARGUMENTS FOR THIS ROUTINE ARE THE NAME
;OF THE MOTION PROGRAM TO BE EDITED AND THE INSTRUCTION LINE
;NUMBER TO BEGIN WORK.  IF THE PROGRAM NAME IS OMITTED, THE
;PREVIOUS PROGRAM NAME IS USED.  IF IN ADDITION, THE LINE NUMBER
;IS OMITTED, EDITING WILL PICK UP FROM THE POINT WHERE EDITING
;WAS LAST TERMINATED.

;REGISTERS USED:
;
;	ALL REGISTERS ARE AVAILABLE FOR USE

EDIT:	SUB	#6,SP		;MAKE ROOM FOR PROG/STEP INFO
	MOV	@#EDSNUM,R3	;PREVIOUS STEP NUMBER
	MOV	10(SP),R0	;PICK UP PROGRAM NAME
	BNE	EDIT1
	MOV	@#EDPROG,R0	;USE SAME PROGRAM AS LAST TIME
	BNE	EDIT2
	MOV	#NOPROG,R1	;SIGNAL ERROR IF NOT DEFINED
	JSR	PC,TYPERR
	BR	EDTEXX
EDIT1:	MOV	#1,R3		;DEFAULT STEP = 1
EDIT2:	MOV	12(SP),R2	;PICK UP LINE NUMBER
	BGT	EDIT3
	MOV	R3,R2		;USE DEFAULT OR OLD VALUE

;SWITCH START EXECUTION FROM HERE

EDIT3:	MOV	#EDTME2,SG	;TYPE PROGRAM NAME
	JSR	PC,PACNME
	MOV	#EDTMES,SG
	JSR	PC,LINOUT
	MOV	R0,PPTR(SP)	;INITIALIZE PROG/STEP INFO
	ADD	#FSTSTP,R0
	MOV	R0,OPTR(SP)
	MOV	#1,SNUM(SP)
	DEC	R2		;ADVANCE TO PROPER STEP NUMBER
	BNE	MVEDWN
EDITLP:	MOV	SNUM(SP),R0	;PRINT THE CURRENT MOTION INST.
	MOV	@OPTR(SP),R1
	JSR	PC,PSTEP
	MOV	#OUTBUF,SG	;STEP NUMBER STILL IN OUTBUF
	MOVB	#77,OUTBUF+7 	;+ ?
	CLRB	OUTBUF+10
	JSR	PC,TYPSTR	;TYPE STEP NUMBER ?
	MOV	#INBUF,SG	;READ IN A RESPONSE
	JSR	PC,INSTR
	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	#EMTYPE,R1	;CAN BE EDIT OR MOTION INST
	JSR	PC,PUSARG
	BCC	EDIT4		;BRANCH IF DECODED PROPERLY
	TST	R1
	BEQ	NXTLNE		;GO TO NEXT LINE IF C/R TYPED
	JSR	PC,TYPERR	;ELSE INPUT ERROR
	BR	EDITLP
EDIT4:	CMPB	#EDITIN,TYPBIT(R0)	;EDIT INSTRUCTION?
	BNE	EDIT5
        JSR	PC,@FUNPTR(R0)	;EXECUTE EDIT FUNCTION
	ADD	#20,SP		;CLEAR ARGUMENT LIST
	BR	EDITLP
EDIT5:	MOV	R0,-(SP)	;SAVE NEW MOTION INST PTR
	MOV	@OPTR2(SP),R0	;PTR TO OLD MOTION INSTRUCTION
	BEQ	EDIT6
	MOV	(R0),@OPTR2(SP)	;DELETE OLD INSTRUCTION STEP
	JSR	PC,RELBLK
EDIT6:	MOV	(SP)+,R0	;CREATE NEW INSTRUCTION BLOCK
	JSR	PC,FILLI
	ADD	#20,SP		;CLEAR ARGUMENT LIST
	BR	EDITLP
NXTLNE:	MOV	#1,R2		;MOVE TO NEXT LINE
MVEDWN:	TST	@OPTR(SP)	;END OF PROGRAM?
	BEQ	EDITLP		;YES
	MOV	@OPTR(SP),OPTR(SP)	;NO, MOVE TO NEXT STEP
	INC	SNUM(SP)
	SOB	R2,MVEDWN
	BR	EDITLP

TERMIN:	ADD	#22,SP		;CLEAR SUBR. ARGUMENTS
EDTDNE:	MOV	PPTR(SP),@#EDPROG	;SAVE PROGRAM AND STEP NUMBER
	MOV	SNUM(SP),@#EDSNUM
EDTEXX:	ADD	#6,SP
       	RTS	PC

EDTMES:	.ASCII	/EDITING USER PROGRAM /
EDTME2:	.ASCII	/         /
	.EVEN

;END OF "EDIT"
;"DEFPRO" - COMMAND INSTRUCTION
 
;THIS COMMAND IS USED FOR READING IN A MOTION PROGRAM THAT HAS
;BEEN DUMPED OUT.  IT REQUIRES AS ITS ONLY ARGUMENT A POINTER
;TO A USER PROGRAM SYMBOL BLOCK.  IF THE USER PROGRAM ALREADY
;HAS SOME STEPS DEFINED,  AFTER CONFIRMATION, ALL EXISTING STEPS
;ARE DELETED BEFORE THE NEW PROGRAM IS READ.

;REGISTERS USED:
;
;	ALL REGISTERS ARE AVAILABLE FOR USE

DEFPRO:	MOV	2(SP),R3	;PICK UP PROGRAM NAME
	MOV	R3,-(SP)	;INITIALIZE PROG/STEP INFO
	MOV	#1,-(SP)
	ADD	#FSTSTP,R3
	MOV	R3,-(SP)
	TST	(R3)		;PROGRAM STEPS ALREADY DEFINED?
	BEQ	DEFPR1		;NO
	BR	DEFDL2		;DELETE ALL EXISTING STEPS
DEFDL1:	MOV	R3,R0
	JSR	PC,RELBLK
DEFDL2:	MOV	(R3),R3		;DELETE ONE STEP
	BNE	DEFDL1		;END OF PROGRAM?
	CLR	@OPTR(SP)
DEFPR1:	MOV	#INBUF,SG	;READ IN A STEP
	JSR	PC,INSTR
	JSR	PC,GETINT	;STRIP OFF LINE NUMBER
	BCC	DEFPR2
	TST	R1
	BNE	DEFPER
DEFPR2:	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	#MOTION,R1	;MOTION INSTRUCTION?
	JSR	PC,PUSARG
	BCS	DEFPR3		;BRANCH IF DECODED IMPROPERLY
	JSR	PC,FILLI
	ADD	#20,SP		;CLEAR ARGUMENT LIST
	BR	DEFPR1
DEFPR3:	TST	R1
	BEQ	DEFPDN		;EMPTY LINE MARKS END
DEFPER:	JSR	PC,TYPERR	;TYPE ERROR MESSAGE
DEFPDN:	ADD	#6,SP		;CLEAR STACK
       	RTS	PC


;END OF "DEFPRO"
;"SWITCH" - EDIT INSTRUCTION

;THIS FUNCTION SWITCHES THE USER PROGRAM BEING EDITED.  IT REQUIRES A
;POINTER TO THE SYMBOL BLOCK FOR THE NEW USER PROGRAM AND AN OPTIONAL
;STARTING LINE NUMBER.

;REGISTERS USED:
;
;	R0,R1,R2,R3 ARE GARBAGED

SWITCH:	MOV	2(SP),R0	;NEW PROGRAM
	MOV	4(SP),R2	;STARTING LINE NUMBER
	BGT	.+6
	MOV	#1,R2		;DEFAULT = STEP 1
	ADD	#22,SP		;CLEAR ARGS AND RET. ADDR
	JMP	EDIT3		;RESTART EDIT PROGRAM

;END OF "SWITCH"
;"DELETE" - EDIT INSTRUCTION

;THIS FUNCTIONS DELETES AN ARBITRARY NUMBER OF MOTION INSTRUCTIONS
;STARTING WITH THE CURRENT LINE.  IT REQUIRES AS ITS ONLY ARGUMENT A
;COUNT OF THE NUMBER OF LINES TO DELETE. IF THE COUNT IS NEGATIVE,
;NO DELETING IS DONE.

;REGISTERS USED:
;
;	R0,R1,R2,R3 ARE GARBAGED

DELETE:	MOV	2(SP),R2	;NUMBER OF STEPS TO DELETE
	BLT	DELTXX		;EXIT IF # < 0
	BNE	.+6
	MOV	#1,R2		;DEFAULT IS ONE STEP
	MOV	@OPTR2(SP),R3	;PTR TO CURRENT STEP
DELE1:	MOV	R3,R0		
      	BEQ	DELTDN		;ALL DONE IF END OF PROG
	MOV	(R3),R3		;DELETE ONE STEP
	JSR	PC,RELBLK
	SOB	R2,DELE1	;REPEAT TILL DONE
DELTDN:	MOV	R3,@OPTR2(SP)	;SAVE NEW CURRENT STEP
DELTXX:	RTS	PC


;END OF "DELETE"
;"INSERT" - EDIT INSTRUCTION

;THIS EDIT FUNCTION ALLOWS THE USER TO INSERT AN ARBITRARY NUMBER OF
;NEW MOTION INSTRUCTIONS IN BETWEEN EXISTING INSTRUCTIONS.  NO
;ARGUMENTS ARE REQUIRED BY THIS ROUTINE OTHER THAN THE POINTERS SET
;UP ON THE STACK BY "EDIT".  THIS MODE IS TERMINATED BY TYPING ANY
;ILLEGAL MOTION INSTRUCTION OR AN EMPTY LINE.

;REGISTERS USED:
;
;	R0,R1 GARBAGED

INSERT:	MOV	SNUM2(SP),-(SP)	;COPY CURRENT LINE # AND PTR
	MOV	SNUM2(SP),-(SP)
INSTLP:	MOV	#OUTBUF,SG	;TYPE THE CURRENT LINE NUMBER AND ?
	MOV	SNUM(SP),R0	;STEP NUMBER
	JSR	PC,PRTINT
	MOVB	#77,(SG)+	;"?"
	CLRB	(SG)
	MOV	#OUTBUF,SG
	JSR	PC,TYPSTR
	MOV	#INBUF,SG	;READ IN A MOTION INSTRUCTION
	JSR	PC,INSTR
	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	#MOTION,R1	;MOTION INSTRUCTION?
	JSR	PC,PUSARG
	BCS	INSRDN 		;BRANCH IF NOT
	JSR	PC,FILLI	;INSERT THE NEW INSTRUCTION
	ADD	#20,SP		;CLEAR ARGS
	BR	INSTLP
INSRDN:	TST	R1		;EMPTY LINE?
	BEQ	.+6
	JSR	PC,TYPERR	;NO, INPUT ERROR OCCURRED
	MOV	(SP)+,SNUM2(SP)	;SAVE NEW CURRENT LINE # AND PTR
	MOV	(SP)+,SNUM2(SP)
	RTS	PC

;END OF "INSERT"
;"PRINT" - EDIT INSTRUCTION

;THIS EDIT FUNCTION PRINTS OUT AN ARBITRARY NUMBER OF STEPS OF A
;USER MOTION PROGRAM.  IT REQUIRES AS ITS ONLY ARGUMENT A COUNT
;OF THE NUMBER OF STEPS TO BE PRINTED.  AFTER EXECUTION, THE 
;CURRENT LINE POINTER IS LEFT POINTING AT THE LAST STEP PRINTED.

;REGISTERS USED:
;
;	R0,R1,R2 GARBAGED

PRINT:	MOV	2(SP),R2	;NUMBER OF LINES TO PRINT
	BLT	PRNTDN		;NOTHING TO DO IF COUNT < 0
	BNE	.+6
	MOV	#1,R2		;DEFAULT IS PRINT 1 STEP
	BR	PRNSTR
PRNTLP:	MOV	SNUM2(SP),R0	;ELSE PRINT THE STEP
	JSR	PC,PSTEP
PRNSTR:	MOV	@OPTR2(SP),R1	;AT LAST STEP?
	BEQ	PRNTDN		;CANT MOVE PAST LAST STEP
	MOV	R1,OPTR2(SP)	;ELSE MOVE ON TO NEXT STEP
	INC	SNUM2(SP)
	MOV	(R1),R1		;IS THIS THE LAST STEP?
	BEQ	PRNTDN		;YES
	SOB	R2,PRNTLP	;PRINTED ALL REQUESTED STEPS?
PRNTDN:	RTS	PC
	

;END OF "PRINT"
;"SKIP"&"LAST" - EDIT INSTRUCTIONS

;THE FOLLOWING EDIT FUNCTIONS ARE USED FOR MOVING THE CURRENT LINE
;POINTER FORWARD AND BACKWARD THROUGH THE USER PROGRAM.  "LAST"
;DECREMENTS THE MOTION STEP POINTER AND REQUIRES NO ARGUMENT.  "SKIP"
;MOVES THE CURRENT LINE POINTER TO AN ARBITRARY STEP NUMBER.  "SKIP"
;REQUIRES AS ITS ONLY ARGUMENT, A LINE NUMBER.  BOT ROUTINES
;MODIFY THE "EDIT" POINTERS ON THE STACK.

;REGISTERS USED:
;
;	R0,R1,R2 GARBAGED

LAST:	MOV	#-1,R2		;MOVE STEP POINTER BACK ONE
	BR	MOVBCK

SKIP:	MOV	2(SP),R2	;GET NUMBER OF STEPS TO SKIP
	SUB	SNUM2(SP),R2
	BEQ	SKIPDN		;NOTHING TO DO IF ZERO
	BGT	FORWRD
MOVBCK:	MOV	PPTR2(SP),R0	;MOVING BACK, STEP FROM 0
	ADD	#FSTSTP,R0
	MOV	R0,OPTR2(SP)
	ADD	SNUM2(SP),R2	;NOW HOW MANY STEPS FORWARD?
	MOV	#1,SNUM2(SP)
	DEC	R2
	BLE	SKIPDN		;CANT BACK UP PAST STEP 1
FORWRD:	TST	@OPTR2(SP)	;CANT MOVE PAST LAST STEP
	BEQ	SKIPDN
	MOV	@OPTR2(SP),OPTR2(SP)	;MOVE DOWN A STEP
	INC	SNUM2(SP)
	SOB	R2,FORWRD
SKIPDN:	RTS	PC

;END OF "LAST"&"SKIP"
;"FILLI"  - EDIT SUBROUTINE

;INSERTS A MOTION INSTRUCTION BETWEEN THE LAST AND THE CURRENT STEPS.
;A POINTER TO THE MOTION INSTRUCTION SYMBOL BLOCK IS ASSUMED TO BE IN
;R0 AND THE ARGUMENTS ARE ASSUMED TO BE ON THE STACK.  A SAMPLE
;CALLING SEQUENCE FOLLOWS:
;
;			MOV	#MOTIONBLK,R0
;			JSR	PC,FILLI
;
;AFTER EXECUTION, THE "EDIT" POINTERS ON THE STACK ARE UPDATED TO
;POINT TO THE INSTRUCTION FOLLOWING THE NEW INSERTED STEP.

;REGISTERS USED:
;	R0,R1,R2,R3,R4 GARBAGED

FILLI:	MOV	R0,R2		;SAVE PTR TO MOTION SYM. BLK
	MOV	SP,R3		;PTR TO ARGUMENTS
	TST	(R3)+
	MOVB	NUMARG(R0),R4	;NUMBER OF ARGUMENTS
	BEQ	SAVINS
	CMP	#STRING,FUNARG(R2)	;1 STRING ARG?
	BNE	SAVINS		;BRANCH IF NOT
	MOV	2(SP),R3	;COUNT THE NUMBER OF CHARS IN STG
CNTCHR:	INC	R4
	CMPB	#15,(R3)+
	BNE	CNTCHR
	CLRB	-(R3)		;END STRING WITH 0 INSTEAD OF CR
	ASR	R4		;CONVERT TO WORD COUNT
	MOV	2(SP),R3	;START SAVING FROM HERE
SAVINS:	MOV	R4,R0		;# OF WORDS IN INST. BLOCK
	ADD	#2,R0
	JSR	PC,GETBLK	;GET SOME STORAGE SPACE
	BCS	FILDNE		;EXIT IF NONE LEFT
	MOV	@OPTR2(SP),(R0)	;LINK IN NEW STEP
	MOV	R0,@OPTR2(SP)
	MOV	R0,OPTR2(SP)
	INC	SNUM2(SP)	;INDICATE ONE MORE STEP
	TST	(R0)+
	MOV	R2,(R0)+	;SET PTR TO MOTION INST. BLK
	ASL	R4		;ANY ARGUMENTS?
	BEQ	FILDNE
	MOVB	(R3)+,(R0)+	;SAVE THE ARGUMENTS
	SOB	R4,.-2
	BR	FILDNE
	JSR	PC,TYPERR	;TYPE F.S. ERROR MESSAGE
FILDNE:	RTS	PC

.END
β